package server

import (
	"encoding/json"
	"synthesis-server/model"

	//"encoding/json"
	"fmt"
	"github.com/gorilla/websocket"
	//"synthesis-server/model"
)

//定义一个client来映射客户端的websocket连接
type Client struct {
	Name     string
	Conn     *websocket.Conn
	Send     chan []byte
	Working  bool
	IsServer bool
	IsLining bool
}

/*
		客户端的读方法,与客户端开启websocket连接以后监听客户是否发送消息,并从消息中选择要发送的对象
	并转发
*/

func (c *Client) Read() {

	// 析构函数
	defer func() {
		c.Conn.Close()
	}()

	for true {
		_, message, err := c.Conn.ReadMessage() //读前端的真实message

		//1.首先确认该客户是否正在进行通话
		_, ok := MyServer.Calling[c]

		if err != nil {
			fmt.Println("读取信息错误,用户或已经掉线")
			fmt.Println(c.Name)
			fmt.Println(err)
			if ok {
				fmt.Println("调用了3")
				HangUp(c)
				fmt.Println("调用了")
			} else if c.IsLining {
				MyServer.CancelLine <- c
			}

			//如果是服务器刷新页面，挂断当前通话
			if c.IsServer {
				t := true
				for k, v := range MyServer.Calling {
					if v.Name == c.Name {
						t = false
						//挂断当前客户的通话
						d := model.Datas{DataType: "disconnected", DataContent: "与您对话的客服意外掉线了"}
						m := model.Msg{Data: d}
						data, err := json.Marshal(m)
						if err != nil {
							fmt.Println("服务器向客户发送当前没有客服在线!此会话关闭的消息json序列化不成功!")
						}
						l := k.Conn.WriteMessage(websocket.TextMessage, data)
						if l != nil {
							println("写异常")
						}

						delete(MyServer.Calling, k)
						g := k.Conn.Close()
						if g != nil {
							println("写异常")
						}
						delete(MyServer.Clients, k.Name)

						fmt.Println("客服中断通话")

						//中断当前客服的连接

						MyServer.Mutex.Lock()
						MyServer.OnlineServer--
						MyServer.Mutex.Unlock()
						//如果当前所有客服都挂断电话，正在排队的用户也应该断开连接
						if MyServer.OnlineServer == 0 {
							MyServer.ServerAllDisconnect()
						}

						delete(MyServer.Clients, v.Name)
						MyServer.BroadcastStatus()
						v.Conn.Close()

					}
				}

				if t {
					fmt.Println("客服掉线")
					MyServer.Mutex.Lock()
					MyServer.OnlineServer--
					MyServer.IdleServer.Pop()
					if MyServer.OnlineServer == 0 {
						println("所有客服ds", c.Name)
						MyServer.ServerAllDisconnect()
					}
					delete(MyServer.Clients, c.Name)
					MyServer.Mutex.Unlock()
					c.Conn.Close()

					MyServer.BroadcastStatus()
				}
			}

			break
		}

		var msg = &model.Message{}
		e := json.Unmarshal([]byte(string(message)), &msg) //变成json对象
		if e != nil {
			fmt.Println("解析通话中的客户的消息为json时出错")
		}

		if ok {
			//2.确认客户是否要结束通话
			//读取客户发送的message

			if msg.Content == "disconnect" {
				////客户请求中断通话
				//d := model.Datas{DataType: "disconnected"}
				//m := model.Msg{Data: d}
				//data, err := json.Marshal(m)
				//if err != nil {
				//	fmt.Println("服务器向客户发送当前没有客服在线!此会话关闭的消息json序列化不成功!")
				//}
				//c.Conn.WriteMessage(websocket.TextMessage, data)
				//delete(MyServer.Clients, c.Name)
				//c.Conn.Close()
				//
				//s := MyServer.Calling[c]
				//
				//delete(MyServer.Calling, c)
				//
				//if s.Working {
				//	//如果客服没有选择中断接单
				//	fmt.Println("客服没有中断通话")
				//
				//	d := model.Datas{DataType: "client hang up"}
				//	m := model.Msg{Data: d}
				//	data, err := json.Marshal(m)
				//	if err != nil {
				//		fmt.Println("服务器向客服发送客户挂断消息json序列化失败")
				//	}
				//	s.Conn.WriteMessage(websocket.TextMessage, data)
				//	MyServer.IdleServer.Add(s)
				//	MyServer.ServerIn <- s
				//} else {
				//	//如果客服选择中断接单
				//
				//	fmt.Println("客服中断通话")
				//
				//	d := model.Datas{DataType: "disconnected"}
				//	m := model.Msg{Data: d}
				//	data, err := json.Marshal(m)
				//	if err != nil {
				//		fmt.Println("客服暂停接单中断socket连接的消息json序列化不成功!")
				//	}
				//	s.Conn.WriteMessage(websocket.TextMessage, data)
				//	MyServer.Mutex.Lock()
				//	MyServer.OnlineServer--
				//	MyServer.Mutex.Unlock()
				//	delete(MyServer.Clients, s.Name)
				//	s.Conn.Close()
				//
				//
				//
				//}

				HangUp(c)

			} else {
				//服务器转发消息
				MyServer.Send <- message
			}

		}

		if c.IsServer {
			if msg.Content == "disconnect" {
				//客服选择暂停接单
				c.Working = false

				d := model.Datas{DataType: "request commit"}
				m := model.Msg{Data: d}
				data, err := json.Marshal(m)
				if err != nil {
					fmt.Println("客服暂停接单中断socket连接的消息json序列化不成功!")
				}
				lo := c.Conn.WriteMessage(websocket.TextMessage, data)
				if lo != nil {
					fmt.Println("写异常")
				}

				//MyServer.Mutex.Lock()
				//MyServer.OnlineServer--
				//MyServer.Mutex.Unlock()

				//如果当前所有客服都挂断电话，正在排队的用户也应该断开连接
				//if MyServer.OnlineServer == 0 {
				//	ServerAllDisconnect()
				//}

				//MyServer.BroadcastStatus()

			} else {
				//服务器转发消息
				MyServer.Send <- message
			}
		}

		if msg.Content == "cancelLine" {
			//客户取消排队
			fmt.Println("有客户取消了排队")
			MyServer.CancelLine <- c
		}

	}

}

func (c *Client) Write() { //给前端写回
	defer func() {
		c.Conn.Close()
	}()

	for message := range c.Send {
		err := c.Conn.WriteMessage(websocket.TextMessage, message)
		if err != nil {
			break
		}
	}
}

func HangUp(c *Client) {
	//客户请求中断通话
	d := model.Datas{DataType: "disconnected"}
	m := model.Msg{Data: d}
	data, err := json.Marshal(m)
	if err != nil {
		fmt.Println("服务器向客户发送当前没有客服在线!此会话关闭的消息json序列化不成功!")
	}
	c.Conn.WriteMessage(websocket.TextMessage, data)
	delete(MyServer.Clients, c.Name)
	c.Conn.Close()

	s, o := MyServer.Calling[c]

	if o {
		delete(MyServer.Calling, c)
		_, ok := MyServer.Clients[s.Name]
		if ok {

			if s.Working {
				//如果客服没有选择中断接单
				fmt.Println("客服没有中断通话")
				d := model.Datas{DataType: "client hang up"}
				m := model.Msg{Data: d}
				data, err := json.Marshal(m)
				if err != nil {
					fmt.Println("服务器向客服发送客户挂断消息json序列化失败")
				}

				MyServer.Mutex.Lock()
				s.Conn.WriteMessage(websocket.TextMessage, data)
				MyServer.Mutex.Unlock()

				//MyServer.IdleServer.Add(s)
				MyServer.ServerIn <- s
			} else {
				//如果客服选择中断接单

				fmt.Println("客服中断通话")

				d := model.Datas{DataType: "disconnected"}
				m := model.Msg{Data: d}
				data, err := json.Marshal(m)
				if err != nil {
					fmt.Println("客服暂停接单中断socket连接的消息json序列化不成功!")
				}

				MyServer.Mutex.Lock()
				s.Conn.WriteMessage(websocket.TextMessage, data)
				MyServer.Mutex.Unlock()

				////如果当前所有客服都挂断电话，正在排队的用户也应该断开连接
				//if MyServer.OnlineServer == 0 {
				//	ServerAllDisconnect()
				//}

				delete(MyServer.Clients, s.Name)
				s.Conn.Close()

			}
		}
	}

	MyServer.BroadcastStatus()

}

///*
//	当客服全部不在线时调用此方法
//*/
//func ServerAllDisconnect() {
//	n := len(MyServer.WaitingClient.Data)
//	for i := 0; i < n; i++ {
//		c := MyServer.WaitingClient.Pop()
//
//		d := model.Datas{DataType: "disconnected", DataContent: "所有客服已掉线"}
//		m := model.Msg{Data: d}
//		data, err := json.Marshal(m)
//		if err != nil {
//			fmt.Println("服务器向客户发送当前没有客服在线!此会话关闭的消息json序列化不成功!")
//		}
//		or := c.Conn.WriteMessage(websocket.TextMessage, data)
//		if or != nil {
//			fmt.Println("用户掉线,写方法错误")
//		}
//		delete(MyServer.Clients, c.Name)
//		p := c.Conn.Close()
//		if p != nil {
//			println("关闭")
//		}
//	}
//}
